/**
 * 网络状态监控组合式函数
 * 提供网络连接状态检测和错误处理功能
 */

import { ref, onMounted, onUnmounted } from 'vue'
import { ElMessage } from 'element-plus'

export interface NetworkError {
  type: 'network' | 'timeout' | 'server' | 'unknown'
  message: string
  code?: number
  retry?: () => Promise<void>
}

/**
 * 网络状态管理Hook
 */
export function useNetworkStatus() {
  /** 网络连接状态 */
  const isOnline = ref(navigator.onLine)
  
  /** 网络错误信息 */
  const networkError = ref<NetworkError | null>(null)
  
  /** 是否正在重试 */
  const isRetrying = ref(false)
  
  /**
   * 处理网络状态变化
   */
  function handleOnline() {
    isOnline.value = true
    networkError.value = null
    ElMessage.success('网络连接已恢复')
  }
  
  function handleOffline() {
    isOnline.value = false
    setNetworkError({
      type: 'network',
      message: '网络连接已断开，请检查网络设置'
    })
    ElMessage.error('网络连接已断开')
  }
  
  /**
   * 设置网络错误
   */
  function setNetworkError(error: NetworkError) {
    networkError.value = error
  }
  
  /**
   * 清除网络错误
   */
  function clearNetworkError() {
    networkError.value = null
  }
  
  /**
   * 解析API错误
   */
  function parseApiError(error: any): NetworkError {
    // 网络连接错误
    if (!navigator.onLine) {
      return {
        type: 'network',
        message: '网络连接已断开，请检查网络设置'
      }
    }
    
    // 请求超时
    if (error.code === 'ECONNABORTED' || error.message?.includes('timeout')) {
      return {
        type: 'timeout',
        message: '请求超时，请检查网络连接或稍后重试'
      }
    }
    
    // 服务器错误
    if (error.response) {
      const status = error.response.status
      const data = error.response.data
      
      switch (status) {
        case 400:
          return {
            type: 'server',
            message: data?.message || '请求参数错误',
            code: status
          }
        case 401:
          return {
            type: 'server',
            message: '身份验证失败，请重新登录',
            code: status
          }
        case 403:
          return {
            type: 'server',
            message: '没有权限执行此操作',
            code: status
          }
        case 404:
          return {
            type: 'server',
            message: '请求的资源不存在',
            code: status
          }
        case 429:
          return {
            type: 'server',
            message: '请求过于频繁，请稍后重试',
            code: status
          }
        case 500:
          return {
            type: 'server',
            message: '服务器内部错误，请稍后重试',
            code: status
          }
        case 502:
        case 503:
        case 504:
          return {
            type: 'server',
            message: '服务器暂时不可用，请稍后重试',
            code: status
          }
        default:
          return {
            type: 'server',
            message: data?.message || `服务器错误 (${status})`,
            code: status
          }
      }
    }
    
    // 网络请求失败
    if (error.request) {
      return {
        type: 'network',
        message: '无法连接到服务器，请检查网络连接'
      }
    }
    
    // 其他错误
    return {
      type: 'unknown',
      message: error.message || '未知错误，请重试'
    }
  }
  
  /**
   * 处理API错误并显示用户友好提示
   */
  function handleApiError(error: any, retryFn?: () => Promise<any>) {
    const networkError = parseApiError(error)
    
    // 添加重试函数
    if (retryFn) {
      networkError.retry = retryFn
    }
    
    setNetworkError(networkError)
    
    // 显示错误消息
    ElMessage.error(networkError.message)
    
    return networkError
  }
  
  /**
   * 重试网络请求
   */
  async function retryRequest(retryFn: () => Promise<any>) {
    if (isRetrying.value) return
    
    try {
      isRetrying.value = true
      clearNetworkError()
      
      await retryFn()
      
      ElMessage.success('操作成功')
    } catch (error) {
      handleApiError(error, retryFn)
    } finally {
      isRetrying.value = false
    }
  }
  
  /**
   * 检查网络连接
   */
  async function checkNetworkConnection(): Promise<boolean> {
    try {
      // 尝试发送一个简单的请求来检测网络连接
      const response = await fetch('/api/health', {
        method: 'GET',
        cache: 'no-cache',
        signal: AbortSignal.timeout(5000)
      })
      
      return response.ok
    } catch (error) {
      return false
    }
  }
  
  /**
   * 生命周期管理
   */
  onMounted(() => {
    window.addEventListener('online', handleOnline)
    window.addEventListener('offline', handleOffline)
  })
  
  onUnmounted(() => {
    window.removeEventListener('online', handleOnline)
    window.removeEventListener('offline', handleOffline)
  })
  
  return {
    // 响应式数据
    isOnline,
    networkError,
    isRetrying,
    
    // 方法
    setNetworkError,
    clearNetworkError,
    parseApiError,
    handleApiError,
    retryRequest,
    checkNetworkConnection
  }
}